﻿#define _CRT_SECURE_NO_WARNINGS

//// 由于引⽤折叠限定，f1实例化以后总是⼀个左值引用
//
//template<class T>
//void f1(T& x)
//{}
//
//// 由于引⽤折叠限定，f2实例化后可以是左值引⽤，也可以是右值引用
//template<class T>
//void f2(T&& x)
//{}
//
//int main()
//{
//	typedef int& lref;
//	typedef int&& rref;
//	int n = 0;
//
//	lref& r1 = n; // r1 的类型是 int& 
//	lref&& r2 = n; // r2 的类型是 int& 
//	rref& r3 = n; // r3 的类型是 int& 
//	rref&& r4 = 1; // r4 的类型是 int&& 
//
//	// 没有折叠->实例化为void f1(int& x) 
//	f1<int>(n);
//	f1<int>(0); // 报错 
//
//	// 折叠->实例化为void f1(int& x) 
//	f1<int&>(n);
//	f1<int&>(0); // 报错 
//
//	// 折叠->实例化为void f1(int& x) 
//	f1<int&&>(n);
//	f1<int&&>(0); // 报错 
//
//	// 折叠->实例化为void f1(const int& x) 
//	f1<const int&>(n);
//	f1<const int&>(0);
//
//	// 折叠->实例化为void f1(const int& x) 
//	f1<const int&&>(n);
//	f1<const int&&>(0);
//
//	// 没有折叠->实例化为void f2(int&& x) 
//	f2<int>(n); // 报错 
//	f2<int>(0);
//
//	// 折叠->实例化为void f2(int& x) 
//	f2<int&>(n);
//	f2<int&>(0); // 报错 
//
//	// 折叠->实例化为void f2(int&& x) 
//	f2<int&&>(n); // 报错 
//	f2<int&&>(0);
//
//	return 0;
//}


//template<class T>
//void Function(T&& t)
//{
//	int a = 0;
//	T x = a;
//	//x++;
//
//	cout << &a << endl;
//	cout << &x << endl << endl;
//}
//
//int main()
//{
//	// 10是右值，推导出T为int，模板实例化为void Function(int&& t) 
//	Function(10); // 右值 
//
//	int a;
//	// a是左值，推导出T为int&，引⽤折叠，模板实例化为void Function(int& t) 
//	Function(a); // 左值 
//
//	// std::move(a)是右值，推导出T为int，模板实例化为void Function(int&& t) 
//	Function(std::move(a)); // 右值 
//
//	const int b = 8;
//	// a是左值，推导出T为const int&，引⽤折叠，模板实例化为void Function(const int& t)
//	// 所以Function内部会编译报错，x不能++ 
//	Function(b); // const 左值 
//
//	// std::move(b)右值，推导出T为const int，模板实例化为void Function(const int&& t)
//	// 所以Function内部会编译报错，x不能++ 
//	Function(std::move(b)); // const 右值 
//
//	return 0;
//}

//template<class T>
//void Function(T&& t)
//{
//	Fun(t);
//}
//
//int main()
//{
//	// 10是右值，推导出T为int，模板实例化为void Function(int&& t) 
//	Function(10);			// 右值 
//
//	int a;
//	// a是左值，推导出T为int&，引⽤折叠，模板实例化为void Function(int& t) 
//	Function(a);			// 左值 
//
//	// std::move(a)是右值，推导出T为int，模板实例化为void Function(int&& t) 
//	Function(std::move(a));	// 右值 
//
//	const int b = 8;
//	// a是左值，推导出T为const int&，引⽤折叠，模板实例化为void Function(const int& t)
//	Function(b);			// const 左值
//
//	// std::move(b)右值，推导出T为const int，模板实例化为void Function(const int&& t)
//	Function(std::move(b)); // const 右值 
//
//	return 0;
//}

//int main()
//{
//	// ⼀个简单的lambda表达式 
//	auto add1 = [](int x, int y)->int {return x + y; };
//	cout << add1(1, 2) << endl;
//
//	// 1、捕捉为空也不能省略 
//	// 2、参数为空可以省略 
//	// 3、返回值可以省略，可以通过返回对象⾃动推导 
//	// 4、函数体不能省略 
//	auto func1 = []
//		{
//			cout << "hello bit" << endl;
//			return 0;
//		};
//
//	func1();
//
//	int a = 0, b = 1;
//	auto swap1 = [](int& x, int& y)
//		{
//			int tmp = x;
//			x = y;
//			y = tmp;
//		};
//	swap1(a, b);
//	cout << a << ":" << b << endl;
//
//	return 0;
//}


//int main()
//{
//	vector<Goods> v = { { "苹果", 2.1, 5 }, { "⾹蕉", 3, 4 }, { "橙⼦", 2.2, 3
//   }, { "菠萝", 1.5, 4 } };
//
//	// 类似这样的场景，实现仿函数对象或者函数指针支持商品中 不同项的比较，相对还是比较麻烦的，那么这里lambda就很好用了 
//	// 价格降序
//	sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {
//		return g1._price < g2._price;
//		});
//
//	// 价格升序
//	sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {
//		return g1._price > g2._price;
//		});
//
//	// 评价降序
//	sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {
//		return g1._evaluate < g2._evaluate;
//		});
//
//	// 评价升序
//	sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {
//		return g1._evaluate > g2._evaluate;
//		});
//
//	return 0;
//}

#include <iostream>
using namespace std;

int main()
{
	cout << 1 << endl;

	return 0;
}
